package com.kt.common.coroutines

import kotlinx.coroutines.*
import kotlin.concurrent.thread

/*
fun main() {


    */
/*thread {
        Thread.sleep(1000L) // 非阻塞的等待 1 秒钟（默认时间单位是毫秒）
        println("World!") // 在延迟后打印输出
    }
    println("Hello,") // 协程已在等待时主线程还在继续
    Thread.sleep(2000L) // 阻塞主线程 2 秒钟来保证 JVM 存活*//*


    GlobalScope.launch { // 在后台启动一个新的协程并继续
        delay(1000L) // 非阻塞的等待 1 秒钟（默认时间单位是毫秒）
        println("World!") // 在延迟后打印输出
    }
    println("Hello,") // 协程已在等待时主线程还在继续
    //Thread.sleep(2000L) // 阻塞主线程 2 秒钟来保证 JVM 存活
    runBlocking {     // 但是这个表达式阻塞了主线程
        delay(2000L)  // ……我们延迟 2 秒来保证 JVM 的存活
    }


}*/

/*
fun main() = runBlocking<Unit> {
    GlobalScope.launch {
        delay(2000)
        println("world")
    }
    println("hello")

    delay(3000)//加一个延迟保证jvm存活

    println("end")
}*/

/*
suspend fun main() {
    val launch = GlobalScope.launch {
        delay(1000L)
        println("world")
    }
    println("hello")
    launch.join() // 等待直到子协程执行结束
    println("end")
}*/

//结构化并发
/*fun main ()= runBlocking {
    launch {
        delay(2000L)
        println("world")
    }

    println("hello,")
}*/

//作用域构建器
/*fun main() = runBlocking {
    launch {
        delay(100L)
        println("Task from runBlocking")
    }

    coroutineScope {
        launch {
            delay(500L)
            println("Task instead from coroutineScope")
        }
        delay(100L)
        println("Task from coroutineScope")
    }

    println("Coroutine scope is over")
}*/

//挂起函数
/*
fun main() = runBlocking {
    launch { doHelloWorld() }
    println("hello,")
}

private suspend fun doHelloWorld() {
    delay(100L)
    println("world")
}*/


//fun main() = runBlocking {
//    repeat(100_000) { // 启动大量的协程
//        launch {
//            delay(50L)
//            print(".")
//        }
//    }
//}

/*
fun main() = runBlocking {
    //全局的协程
    GlobalScope.launch {
        repeat(1000){
            println("i'm sleep $it...")
            delay(100L)
        }
    }

    delay(300L)
}*/

fun main() = runBlocking {
    val job = launch {
        try {
            repeat(1000) { i ->
                println("job: I'm sleeping $i ...")
                delay(500L)
            }
        } finally {
//            withContext(NonCancellable) {
                println("job: I'm running finally")
                delay(1000L)
                println("job: And I've just delayed for 1 sec because I'm non-cancellable")
//            }
        }
    }
    delay(1300L) // 延迟一段时间
    println("main: I'm tired of waiting!")
    job.cancelAndJoin() // 取消该作业并等待它结束
    println("main: Now I can quit.")
}